Mac Power 1998 March/MACPOWER-1998-03.ISO.7z/MACPOWER-1998-03.ISO/インターネット／通信/Netscape Communicator Folﾉ.sea/Netscape Communicator Folder/Netscape Communicator™.rsrc/TEXT_3000_initprefs.txt

Text File | 1997-09-08 | 8KB | 372 lines

// Style note 3/3:
// internal objects & functions are in under_score form.
// public functions are in interCaps.

var bAnyPrefLocked = false;

// --- Preference objects ---
function preference(default_value) {
    this.default_value = default_value;
    this.user_value = null;
    this.locked = false;
};

function pref_array(parent) {
    this.parent = parent;
};

function plat() {
    this.windows=false;
    this.mac=false;
    this.unix=false;
};

platform = new plat();

// --- Preference initialization functions ---
//  -- Pass a string and value to a pref function, e.g.
//      user_pref("browser.startup.homepage", "abc");
//  -- It parses the string and defines branches of the prefs
//      object as necessary.
//  -- Note assumptions:
//      Root of the tree is prefs.
//      Every branch is a pref_array and leaves are preference objects.
//
function next_field(str, index)
{
    var i = str.indexOf('.', index);
    if (i == -1)
        i = str.length;
    return str.substring(index, i)
}

function init_prefarray(prefix, name, parent)
{
    if (typeof(prefix[name]) == "undefined") {
        // --ML mime-type hack requiring knowledge of array structure...
        if (parent == "mime" || parent == "static_mime")
            prefix[name] = new mime_type1(prefix);
        else
            prefix[name] = new pref_array(prefix);
    }
}

function init_pref(prefix, name)
{
    if (typeof(prefix[name]) == "undefined")
        prefix[name] = new preference(null);
}

// returns the preference object named by prefname
function init_preftree(prefname)
{
    var index = 0;
    var prefix = prefs;
    var parent = "";
    while (index < prefname.length)
    {
        field = next_field(prefname, index);
        index = index + field.length + 1;

        if (index >= prefname.length) {
            init_pref(prefix, field);
        }
        else {
            init_prefarray(prefix, field, parent);
        }
        prefix = prefix[field];
        parent = field;
    }
    return prefix;
}

// Set to trigger callbacks when setting preferences
var callbacks_enabled = false;

// These functions are exported
function pref(prefname, value)
{
    var pref = init_preftree(prefname);
    pref.default_value = value;
}

// These three for use by autoconfig file
function defaultPref(prefname, value)
{
    // This routine no longer unlocks the pref
    var pref = init_preftree(prefname);
    var changed = pref.default_value != value &&
        (pref.user_value == null || pref.locked);

    pref.default_value = value;

    if (callbacks_enabled && changed)
        pref_changed(prefname);
}

function lockPref(prefname, value)
{
    // Set default pref and lock it
    var pref = init_preftree(prefname);
    var changed = !pref.locked || pref.default_value != value;

    pref.default_value = value;
    pref.locked = true;

    if (bAnyPrefLocked == false && changed) {
        bAnyPrefLocked = true;
        prefLocked();
    }

    if (callbacks_enabled && changed) {
        pref_changed(prefname);
    }
}

function unlockPref(prefname)
{
    var pref = init_preftree(prefname);
    var changed = pref.locked;

    pref.locked = false;

    if (callbacks_enabled && changed)
        pref_changed(prefname);
}

function getPref(prefname)
{
    var pref = init_preftree(prefname);
    return get_user_pref(pref);
}

// 'user_pref' was used in public b2 so keep it
function user_pref(prefname, value)
{
    var pref = init_preftree(prefname);
    if (pref.user_value != value) {
        pref.user_value = value;
        if (callbacks_enabled && !pref.locked)
            pref_changed(prefname);
    }
}

// stubs for compatability
var default_pref = defaultPref;
var lock_pref = lockPref;
var unlock_pref = unlockPref;
var userPref = user_pref;

// -------------------------
prefs = new pref_array(null);


// -------------------------
function mime_type1(parent)
{
    this.parent = parent;
    this.mimetype = new preference("");
    this.extension = new preference("");
    this.load_action = new preference(0);
    this.mac_appname = new preference("");
    this.mac_appsig = new preference("????");
    this.mac_filetype = new preference("????");
    this.mac_plugin_name = new preference("");
    this.description = new preference("");
    this.latent_plug_in = new preference(false);
}

function mime_type(root, mimetype, extension, load_action, appname, appsig, filetype)
{
    init_preftree(root + ".mimetype");
    var mime = init_preftree(root);

    mime.mimetype.default_value = mimetype;
    mime.extension.default_value = extension;
    mime.load_action.default_value = load_action;
    mime.mac_appsig.default_value = appsig;
    mime.mac_appname.default_value = appname;
    mime.mac_filetype.default_value = filetype;
}

// ---
// This is like the func in prefapi, to escape ¥ and "
function str_escape(str)
{
    var outstr = "";
    var next = 0;
    while (next < str.length) {
        var c1 = str.indexOf('¥¥', next);
        var c2 = str.indexOf('¥"', next);
        if (c1 == -1 && c2 == -1) {
            outstr += str.substring(next, str.length);
            next = str.length;
        }
        else {
            var start = next;
            if (c1 == -1)
                next = c2;
            else if (c2 == -1)
                next = c1;
            else
                next = Math.min(c1, c2);
            outstr += str.substring(start, next) + "¥¥" + str.charAt(next);
            next++;
        }
    }
    return outstr;
}

function save_uservals(obj, obj_name)
{
    var result = "";
    var bGroup = false;
    var eol = "¥r";

    if (platform.windows) eol = "¥n";

    for (var i in obj) {
       if (i == "parent") bGroup = true;
        if (i != "parent") {
           if ((i == "user_value") && (obj[i] != null) &&
                  (obj.user_value != obj.default_value))
            {
                result += "user_pref(¥"" + obj_name + "¥", ";

                if (typeof(obj[i]) == "string")
                    result += "¥"" + str_escape(obj[i]) + "¥");";
                else
                    // number or boolean
                    result += obj[i] + ");";
                result += eol;
            }
            if (bGroup) {
                if (obj_name.length == 0)
                    result += save_uservals(obj[i], i);
                else
                    result += save_uservals(obj[i], obj_name + "." + i);
            }
        }
    }
    return result;
}

// -- For building child iterator
function get_children(node, nodename)
{
    var result = "";
    for (var i in node) {
        if (i != "parent" && node[i] != null) {
            result += nodename + "." + i + ";"
        }
    }
    return result;
}

// -- Admin Kit support --
configs = new pref_array(null);

function config(param, value)
{
    init_configtree(param, value);
}

function init_configtree(param, value)
{
    var index = 0;
    var prefix = configs;
    while (index < param.length)
    {
        field = next_field(param, index);
        index = index + field.length + 1;

        if (index >= param.length && value != null) {
            prefix[field] = value;
        }
        else if (typeof(prefix[field]) == "undefined") {
            if (value != null)
                prefix[field] = new pref_array(prefix);
            else
                return null;
        }
        prefix = prefix[field];
    }
    return prefix;
}

// -- These functions are called from within prefapi.c
// -- Returns true iff the pref's value has changed.
// (Set creates the pref if necessary; Get assumes it already exists)
function set_user_pref(prefname, value)
{
    var pref = init_preftree(prefname);

    if (pref.locked)
        return false;

    if (pref.default_value == value) {
        if (pref.user_value == null)
            return false;
        else {
            pref.user_value = null;
            return true;
        }
    }

    if (pref.user_value == value) {
        return false;
    } else {
        pref.user_value = value;
        return true;
    }
}

function get_user_pref(obj)
{
    if (obj.locked || obj.user_value == null) {
        return obj.default_value;
    }
    else {
        return obj.user_value;
    }
}

function set_default_user_pref(prefname, value)
{
    var pref = init_preftree(prefname);

    if (!pref.locked && pref.default_value != value) {
        pref.default_value = value;
        return true;
    }
    return false;
}

function get_config(param)
{
    return init_configtree(param, null);
}

// LDAP
// Searches for "key=value" in the given string and returns value.
function getLDAPValue(str, key)
{
    if (str == null || key == null)
        return null;

    var search_key = "¥n" + key + "=";

    var start_pos = str.indexOf(search_key);
    if (start_pos == -1)
        return null;

    start_pos += search_key.length;

    var end_pos = str.indexOf("¥n", start_pos);
    if (end_pos == -1)
        end_pos = str.length;

    return str.substring(start_pos, end_pos);
}